package com.yidu.hbats.action.mentalTraining;

import com.yidu.hbats.action.vo.AtsSchemeVo;
import com.yidu.hbats.dao.AtsEmpExpertMapper;
import com.yidu.hbats.model.*;
import com.yidu.hbats.service.MentalTraining.AtsSchemeAthleteMentalService;
import com.yidu.hbats.service.MentalTraining.AtsSchemeAuditMentalService;
import com.yidu.hbats.service.MentalTraining.AtsSchemeExpertMentalService;
import com.yidu.hbats.service.MentalTraining.AtsSchemeMentalService;
import com.yidu.hbats.service.emp.AtsEmpAthleteService;
import com.yidu.hbats.service.emp.AtsEmpExpertService;
import com.yidu.springbootdemo.permission.domain.Tuser;
import com.yidu.utils.FileTools;
import com.yidu.utils.Message;
import com.yidu.utils.RedisUtil;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @program: t272
 * @description 心理训练方案的控制层
 * @author: 周佳佳
 * @create: 2019-11-12 09:13
 **/
@Controller
@RequestMapping("mentalTrainingController")
public class MentalTrainingController {
    @Resource
    AtsSchemeExpertMentalService atsSchemeExpertMentalService;
    @Resource
    AtsSchemeMentalService atsSchemeService;
    @Resource
    AtsEmpAthleteService atsEmpAthleteService;
    @Resource
    AtsSchemeAthleteMentalService atsSchemeAthleteMentalService;
    @Resource
    AtsEmpExpertService atsEmpExpertService;
    @Resource
    AtsSchemeAuditMentalService atsSchemeAuditMentalService;
    @Resource
    FileTools fileTools;
    @Resource
    RedisUtil redisUtil;

    /**
     * 心理方案的查询所有
     * @param atsScheme 方案表类
     * @param pageNum  页
     * @param pageSize 行
     * @param request request对象
     * @return  返回一个map对象
     */
    @ResponseBody
    @RequestMapping("selectAll")
    public Map<String,Object> selectAll(AtsScheme atsScheme, @RequestParam("page") Integer pageNum,
                                        @RequestParam("limit") Integer pageSize, HttpServletRequest request){
        //new一个map集合
        Map<String,Object> map=new HashMap<>();
        //用session把登录Tuser模型弄出来
        Tuser user = (Tuser) request.getSession().getAttribute("user");
        //new一个List集合
        List<AtsScheme> list=new ArrayList<>();
        //定义一个int为0
        int count=0;
        //判断用户表的外键关联为空，那就是超级管理员之类的，就可以查看所有
        //为1的是领导 为2的是教练员  为3的是专家 为4的是运动员
        //判断为2就是教练员
       if(user.getCompanyNum()=="2"||"2".equals(user.getCompanyNum())){
            //方案对象传入教练员的外键
            atsScheme.setCoachId(Integer.valueOf(user.getFilId()));
            //调用查询所有one的方法
            list=atsSchemeService.selectAllone(atsScheme,pageNum,pageSize);
           //调用查询所有one的总行数方法
            count=atsSchemeService.selectCountone(atsScheme);
       //判断数字为4的就是运动员
       }else if(user.getCompanyNum()=="4"||"4".equals(user.getCompanyNum())){
           //用方案表备注字段传入运动员的外键查询
           atsScheme.setRemark(user.getFilId());
           //调用查询运动员的所有方案one
           list=atsSchemeService.selectAthleteAllOne(atsScheme,pageNum,pageSize);
           //调用查询运动员的所有方案的总行数one
           count=atsSchemeService.selectAthleteAllCountOne(atsScheme);
       //判断session里的用户名字为admin 代表超级管理员
       }else if(user.getUserName().equals("admin")){
           //管理员查看所有
           //调用查询所有one的方法
           list=atsSchemeService.selectAllone(atsScheme,pageNum,pageSize);
           //调用查询所有的总行数one的方法
           count=atsSchemeService.selectCountone(atsScheme);
       //判断为1的进来是领导
       }else if(user.getCompanyNum()=="1"||"1".equals(user.getCompanyNum())){
           //领导查看 10 20 21状态的
           //调用audit领导的查看所有方法
           list=atsSchemeService.selectAuditAllOne(atsScheme,pageNum,pageSize);
           //调用audit领导的查看所有的总行数方法
           count=atsSchemeService.selectAuditAllCountOne(atsScheme);
       //判断为3的进来是专家
       }else if(user.getCompanyNum()=="3"||"3".equals(user.getCompanyNum())){
           //专家查看
           //传入备注字段做专家外键
           atsScheme.setRemark(user.getFilId());
           //调用expert专家查询方法
           list=atsSchemeService.selectExpertAllTwo(atsScheme,pageNum,pageSize);
           //调用expert专家查询方法的总行数方法
           count=atsSchemeService.selectExpertAllCountTwo(atsScheme);
       }
        //写layui前台要的json数据类型
        map.put("code", 0);
        map.put("msg", "");
        map.put("count", count);
        map.put("data", list);
        //返回map集合
        return map;
    }

    /**
     * 查询教练员的方法
     * @param coachId 传入教练员id
     * @return 返回一个list集合
     */
    @ResponseBody
    @RequestMapping("checkboxselectAll")
    public List<AtsEmpAthlete> checkboxselectAll(int coachId){
        //调用教练员表的根据id查询方法
        List<AtsEmpAthlete> list=atsEmpAthleteService.selectByCoachIdone(coachId);
        //返回一个list集合
        return list;
    }

    /**
     * 心理方案增加或者修改方法
     * @param atsSchemeVo 方案的vo层 TrainingPlan心理方案文件夹
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("addOrupdate")
    public Message addOrupdate(AtsSchemeVo atsSchemeVo){
        //判断vo里面的文件one不等于空
        if(atsSchemeVo.getFileone().getOriginalFilename()!=null &&!"".equals(atsSchemeVo.getFileone().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file1=fileTools.saveFile("TrainingPlan",atsSchemeVo.getFileone());
                //传入vo的文件地址
                atsSchemeVo.setFile1(file1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //判断vo里面的文件two不等于空
        if(atsSchemeVo.getFiletwo().getOriginalFilename()!=null &&!"".equals(atsSchemeVo.getFiletwo().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file2 = fileTools.saveFile("Trainin·gPlan",atsSchemeVo.getFiletwo());
                //传入vo的文件地址
                atsSchemeVo.setFile2(file2);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //判断vo里面的文件three不等于空
        if(atsSchemeVo.getFilethree().getOriginalFilename()!=null &&!"".equals(atsSchemeVo.getFilethree().getOriginalFilename())){
            try {
                //调用上传文件的方法 第一个参数为文件夹名字 第二个是vo的文件对象
                String file3=fileTools.saveFile("TrainingPlan",atsSchemeVo.getFilethree());
                //传入vo的文件地址
                atsSchemeVo.setFile3(file3);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //判断方案id不等于空
        if(atsSchemeVo.getSchemeId()!=null &&!"".equals(atsSchemeVo.getSchemeId())){
            //调用 生成的修改方法
            atsSchemeService.updateByPrimaryKeySelective(atsSchemeVo);
        }else{
            //调用  生成的增加有选择的方法
            atsSchemeService.insertSelective(atsSchemeVo);
        }
        //new出提示对象传入1
        Message message=new Message();
        message.setNum(1);
        message.setMsg("成功");
        return message;
    }
    @ResponseBody
    @RequestMapping("findAll")
    public AtsScheme findAll(int schemeId){
        AtsScheme atsScheme=atsSchemeService.findByIdOne(schemeId);
        return atsScheme;
    }
    @ResponseBody
    @RequestMapping("findByIdone")
    public List<AtsSchemeAthlete> findByIdone(int schemeId){
        List<AtsSchemeAthlete> list=atsSchemeAthleteMentalService.selectByIdone(schemeId);
        return list;
    }
    /**
     * 逻辑删除
     * @param schemeId 方案主键
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("updateIsva")
    public Message updateIsva(int schemeId){
        //new出提示类
        Message message=new Message();
        //判断方案id不为空
        if(!StringUtils.isEmpty(schemeId)){
            //调用修改方法
            int rows=atsSchemeService.updateByPrimaryKeySelectiveone(schemeId);
            //判断大于0
            if(rows>0){
                //传入1和提示
                message.setNum(1);
                message.setMsg("删除成功!");
            }else{
                //传入1和提示
                message.setNum(1);
                message.setMsg("操作失败!");
            }
        }
        return message;
    }

    /**
     * 批量逻辑删除
     * @param schemeId 字符串方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("deleteAllone")
    public Message deleteAllone(String schemeId){
        //new出提示类
        Message message=new Message();
        //用spring里面的判断方案id不为空
        if(!StringUtils.isEmpty(schemeId)){
            //定义数组然后分割传过来的字符串id
            String[] arr=schemeId.split(",");
            //定义一个int为0
            int one=0;
            //循环数组长度
            for (int i = 0; i < arr.length; i++) {
                //int的变量++
                one++;
                //调用方案的修改方法one
                int rows=atsSchemeService.updateByPrimaryKeySelectiveone(Integer.valueOf(arr[i]));
                //判断大于0
                if(rows>0){
                    //提示类传入删除几行和1
                    message.setNum(1);
                    message.setMsg("删除成功!删除了"+one+"行!");
                }else{
                    message.setNum(1);
                    message.setMsg("操作失败!");
                }
            }
        }
        //返回提示类
        return message;
    }
    @ResponseBody
    @RequestMapping("findAlltwo")
    public List<AtsEmpExpert> findAlltwo(){
        List<AtsEmpExpert> list=atsEmpExpertService.findAllFour();
        return list;
    }
    @ResponseBody
    @RequestMapping("selectByPrimaryKeyOne")
    public AtsScheme selectByPrimaryKeyOne(int schemeId){
        AtsScheme atsScheme=atsSchemeService.selectByPrimaryKey(schemeId);
        return atsScheme;
    }

    /**
     * 增加的方法
     * @param atsSchemeAudit  领导审核表对象
     * @param expertId 专家id
     * @param applyForExp  申请专家理由
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("expertone")
    public Message expertone(AtsSchemeAudit atsSchemeAudit,int expertId,String applyForExp){
        //根据传过来的专家主键查询
        AtsEmpExpert atsScheme=atsEmpExpertService.selectByPrimaryKey(expertId);
        //调用领导审核表增加方法
        int rows=atsSchemeAuditMentalService.insertSelective(atsSchemeAudit);
        //new出提示工具类
        Message message=new Message();
        //判断rows大于0
        if(rows>0){
            //new出专家审核表模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //传入专家名字
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //传入专家id
            atsSchemeExpert.setExpertId(atsScheme.getExpertId().toString());
            //传入方案主键
            atsSchemeExpert.setSchemeId(Integer.valueOf(atsSchemeAudit.getSaId()));
            //传入方案名字
            atsSchemeExpert.setSaName(atsSchemeAudit.getSaName());
            //传入申请专家理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            Date date = new Date();//获取当前的日期
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String str = df.format(date);//获取String类型的时间
            Date utilDate = new Date();//util.Date
            java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDate);
            //默认传入10为咨询状态
            atsSchemeExpert.setAuditState("10");
            //传入创建人
            atsSchemeExpert.setCreater(atsSchemeAudit.getCreater());
            //默认传入1为有效
            atsSchemeExpert.setIsva(1);
            //传入申请咨询时间
            atsSchemeExpert.setApplyForTime(str);
            //调用生成的 增加方法
            atsSchemeExpertMentalService.insertSelective(atsSchemeExpert);
        }
        //提示传入1
        message.setNum(1);
        //提示传入 操作成功
        message.setMsg("操作成功!");
        //返回提示工具对象
        return message;
    }

    /**
     * 查询是否已经提交审核和专家申请
     * @param schemeId
     * @return
     */
    @ResponseBody
    @RequestMapping("selectState")
    public Message selectState(int schemeId){
        Message message=new Message();
        int rows=atsSchemeExpertMentalService.selectByOne(schemeId);
        if(rows>0){
            message.setNum(1);
            message.setMsg("审核和申请已经提交过，是否修改");
        }else{
            message.setNum(0);
        }
        return message;
    }

    /**
     * 修改申请和咨询
     * @param applyForExp 申请理由
     * @param expertId  主键id
     * @param saName  方案名称
     * @param saId  方案外键
     * @return 返回一个提示工具类
     */
    @ResponseBody
    @RequestMapping("updateState")
    public Message updateState(String applyForExp,int expertId,String saName,int saId){
        //根据传过来的专家主键查询
        AtsEmpExpert atsScheme=atsEmpExpertService.selectByPrimaryKey(expertId);
        Message message=new Message();
        if(!StringUtils.isEmpty(expertId)){
            //new出审核表模型
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //传入方案名称参数
            atsSchemeAudit.setSaName(saName);
            //传入方案id参数，要根据id修改
            atsSchemeAudit.setSaId(Integer.valueOf(saId).toString());
            Date utilDate = new Date();//util.Date
            java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
            //传入创建时间
            atsSchemeAudit.setCreatTime(sqlDate);
            atsSchemeAuditMentalService.updateByPrimaryKeySelectivetwo(atsSchemeAudit);
            //new出专家咨询表模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            Date utilDateone = new Date();//util.Date
            java.sql.Date sqlDateone = new java.sql.Date(utilDateone.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDateone);
            //传入方案名称
            atsSchemeExpert.setSaName(saName);
            //传入申请理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            //传入申请时间
            Date date = new Date();//获取当前的日期
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String str = df.format(date);//获取String类型的时间
            //传入申请时间
            atsSchemeExpert.setApplyForTime(str);
            //传入方案外键根据它来修改
            atsSchemeExpert.setSchemeId(saId);
            //传入专家外键
            atsSchemeExpert.setExpertId(atsScheme.getExpertId().toString());
            //传入专家名字
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //调用专家修改方案 生成的one
            atsSchemeExpertMentalService.updateByPrimaryKeySelectiveone(atsSchemeExpert);
            //提示类传1
            message.setNum(1);
            //提示类传 操作成功
            message.setMsg("提交成功!");
        }
        //返回一个对象
        return message;
    }
    @ResponseBody
    @RequestMapping("selectStateAll")
    public Map<String,Object> selectStateAll(AtsSchemeAudit atsSchemeAudit,@RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize){
        Map<String,Object> map=new HashMap<>();
        List<AtsSchemeAudit> list=atsSchemeAuditMentalService.selectByPrimaryKeyTwo(atsSchemeAudit,pageNum,pageSize);
        map.put("code", 0);
        map.put("msg", "");
        map.put("count", atsSchemeAuditMentalService.selectByPrimaryKeyCountTwo(atsSchemeAudit));
        map.put("data", list);
        return map;
    }

    /**
     * 中心领导操作状态
     * @param atsSchemeAudit 中心领导表的对象
     * @param yesOrno 状态
     * @return
     */
    @ResponseBody
    @RequestMapping("auditUpdate")
    public Message auditUpdate(AtsSchemeAudit atsSchemeAudit,int yesOrno){
        //传入审核状态
        atsSchemeAudit.setAuditState(String.valueOf(yesOrno));
        Date date = new Date();//获取当前的日期 newdate
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        String str = df.format(date);//获取String类型的时间
        //传入审核时间
        atsSchemeAudit.setAuTime(str);
        //new出提示工具类
        Message message=new Message();
        //调用领导表的生成修改方案 three
        int rows=atsSchemeAuditMentalService.updateByPrimaryKeySelectivethree(atsSchemeAudit);
        //判断rows大于0
        if(rows>0){
            //new出专家审核表
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //传入方案主键
            atsSchemeExpert.setSchemeId(Integer.valueOf(atsSchemeAudit.getSaId()));
            //传入审核状态
            atsSchemeExpert.setAuditState(String.valueOf(yesOrno));
            //调用生成的修改方法three
            atsSchemeExpertMentalService.updateByPrimaryKeySelectiveThree(atsSchemeExpert);
            //提示类传入话 操作成功
            message.setMsg("操作成功!");
            //提示类传入1
            message.setNum(1);
        }
        //返回提示工具类
        return message;
    }
    @ResponseBody
    @RequestMapping("selectAudit")
    public AtsSchemeAudit selectAudit(int schemeId){
        AtsSchemeAudit atsSchemeAudit=atsSchemeAuditMentalService.selectBySchemeIdFour(schemeId);
        if(StringUtils.isEmpty(atsSchemeAudit)){
            AtsSchemeAudit atsSchemeAudit1=new AtsSchemeAudit();
            atsSchemeAudit1.setAuditState("0");
            return atsSchemeAudit1;
        }
        return atsSchemeAudit;
    }
    @ResponseBody
    @RequestMapping("selectAuditcount")
    public Message selectAuditcount(int schemeId){
        Message message=new Message();
        int rows=atsSchemeAuditMentalService.selectByPrimaryKeyCountThree(schemeId);
        if(rows>0){
            message.setNum(1);
        }else{
            message.setNum(0);
        }
        return message;
    }
    @ResponseBody
    @RequestMapping("selectExperttwo")
    public Map<String,Object> selectExpert(HttpSession session, AtsSchemeExpert atsSchemeExpert, @RequestParam("page") Integer pageNum, @RequestParam("limit") Integer pageSize){
        Map<String,Object> map=new HashMap<>();
        Tuser user = (Tuser) session.getAttribute("user");
        atsSchemeExpert.setExpertId(user.getFilId());
        List<AtsSchemeExpert> list=atsSchemeExpertMentalService.findAllSIx(atsSchemeExpert,pageNum,pageSize);
        map.put("code", 0);
        map.put("msg", "");
        map.put("count", atsSchemeExpertMentalService.countSIx(atsSchemeExpert));
        map.put("data", list);
        return map;
    }
    @ResponseBody
    @RequestMapping("selectExpertState")
    public AtsSchemeExpert selectExpertState(int seId){
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertMentalService.selectByPrimaryKeyFour(seId);
        return atsSchemeExpert;
    }

    /**
     * 根据方案id修改状态
     * @param schemeId 方案id
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("updateExpertState")
    public  Message updateExpertState(int schemeId){
        //new出工具提示类
        Message message=new Message();
        //new出专家回复表
        AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
        //传入方案id
        atsSchemeExpert.setSchemeId(schemeId);
        //传入状态为30
        atsSchemeExpert.setAuditState("30");
        //调用生成的修改方法three
        int rows=atsSchemeExpertMentalService.updateByPrimaryKeySelectiveThree(atsSchemeExpert);
        //判断rows大于0
        if(rows>0){
            //new出领导回复表模型
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //传入方案的id
            atsSchemeAudit.setSaId(String.valueOf(schemeId));
            //传入状态为30
            atsSchemeAudit.setAuditState("30");
            //调用修改方法 生成的four方法
            atsSchemeAuditMentalService.updateByPrimaryKeySelectiveFour(atsSchemeAudit);
            //提示类传入1
            message.setNum(1);
            //提示类传入专家已获知待回复
            message.setMsg("已成专家已获知待回复!");
        }
        //返回提示对象
        return message;
    }

    /**
     * 专家修改的状态
     * @param schemeId 方案id
     * @param results 专家咨询的结果
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("updateResules")
    public Message updateResules(int schemeId,String results){
        //new出提示工具类
        Message message=new Message();
        //new出专家回复模型
        AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
        //传入方案id
        atsSchemeExpert.setSchemeId(schemeId);
        //传入专家咨询结果
        atsSchemeExpert.setResults(results);
        //传入状态为40
        atsSchemeExpert.setAuditState("40");
        //调用生成的修改方案
        int rows=atsSchemeExpertMentalService.updateByPrimaryKeySelective(atsSchemeExpert);
        //判断大于0
        if(rows>0){
            //new出领导审核表
            AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
            //传入方案的id
            atsSchemeAudit.setSaId(String.valueOf(schemeId));
            //传入状态为40
            atsSchemeAudit.setAuditState("40");
            //调用生成方法 four
            atsSchemeAuditMentalService.updateByPrimaryKeySelectiveFour(atsSchemeAudit);
            //传入提示的话
            message.setMsg("您的反馈消息已提交!!!");
            //传入1
            message.setNum(1);
        }
        //返回提示类对象
        return message;
    }

    /**
     * 教练员反馈的方法
     * @param resultEffect 实施效果
     * @param resultExp 实施情况
     * @param schemeId 方案id
     * @param fileone 上传的文件
     * @return 返回提示对象
     */
    @ResponseBody
    @RequestMapping("addScheme")
    public Message addScheme(String resultEffect,String resultExp,int schemeId,@RequestParam(value = "fileone", required = false) MultipartFile fileone){
        //new出提示类
        Message message=new Message();
        //new出方案表模型
        AtsScheme atsScheme=new AtsScheme();
        //判断文件名字不为空
        if(fileone.getOriginalFilename()!=null &&!"".equals(fileone.getOriginalFilename())){
            try {
                //TrainingPlan文件名 调用上传文件方法
                String file1=fileTools.saveFile("TrainingPlan",fileone);
                //传入反馈附件地址
                atsScheme.setResultFile(file1);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Date date = new Date();//获取当前的日期 new一个date
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        String str = df.format(date);//获取String类型的时间
        //传入反馈时间
        atsScheme.setResultTime(str);
        //传入方案的id
        atsScheme.setSchemeId(schemeId);
        //传入实施效果
        atsScheme.setResultEffect(resultEffect);
        //传入实施情况
        atsScheme.setResultExp(resultExp);
        //调用修改的生成方法
        int rows=atsSchemeService.updateByPrimaryKeySelective(atsScheme);
        //判断rows大于0
        if(rows>0){
            //提示类传入1
            message.setNum(1);
            //传入提示语句 反馈成功
            message.setMsg("反馈成功!");
        }
        //返回提示类对象
        return message;
    }
    @ResponseBody
    @RequestMapping("findResults")
    public AtsScheme findResults(int schemeId){
        AtsScheme atsScheme=atsSchemeService.findByIdOne(schemeId);
        return atsScheme;
    }
    @ResponseBody
    @RequestMapping("findstateOne")
    public AtsSchemeExpert findstateOne(int schemeId){
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertMentalService.selectByPrimaryKeyFive(schemeId);
        return atsSchemeExpert;
    }

    /**
     * 中心领导不同意后，继续上传方案
     * @param schemeId 方案主键
     * @param applyForExp 申请理由
     * @param expertId 专家id
     * @param saName 方案名称
     * @return 返回一个提示类
     */
    @ResponseBody
    @RequestMapping("updateStateTwo")
    public Message updateState(Integer schemeId,String applyForExp,Integer expertId,String saName){
        //根据传过来的专家主键查询
        AtsEmpExpert atsScheme=atsEmpExpertService.selectByPrimaryKey(expertId);
        //new出提示类对象
        Message message=new Message();
        //new出中心领导审核模型
        AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
        //模型传入状态为10
        atsSchemeAudit.setAuditState("10");
        //传入方案得外键
        atsSchemeAudit.setSaId(String.valueOf(schemeId));
        //调用修改three的方法
        int rows=atsSchemeAuditMentalService.updateByPrimaryKeySelectivethree(atsSchemeAudit);
        //判断rows大于0
        if(rows>0){
            //new出专家的模型
            AtsSchemeExpert atsSchemeExpert=new AtsSchemeExpert();
            //传入查出来专家名字
            atsSchemeExpert.setExpertName(atsScheme.getExpertName());
            //传入传过来的专家Id
            atsSchemeExpert.setExpertId(String.valueOf(expertId));
            //传入方案Id
            atsSchemeExpert.setSchemeId(schemeId);
            //传入状态为10
            atsSchemeExpert.setAuditState("10");
            //util.Date
            Date utilDateone = new Date();
            //new出sql的date然后用date里获取当前时间方法
            java.sql.Date sqlDateone = new java.sql.Date(utilDateone.getTime());
            //传入创建时间
            atsSchemeExpert.setCreatTime(sqlDateone);
            //传入方案名称
            atsSchemeExpert.setSaName(saName);
            //传入申请理由
            atsSchemeExpert.setApplyForExp(applyForExp);
            //传入申请时间 new一个date
            Date date = new Date();//获取当前的日期
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            String str = df.format(date);//获取String类型的时间
            //传入申请时间
            atsSchemeExpert.setApplyForTime(str);
            //执行修改专家咨询表的方法one
            atsSchemeExpertMentalService.updateByPrimaryKeySelectiveone(atsSchemeExpert);
            //提示类传1
            message.setNum(1);
            //传操作成功话
            message.setMsg("操作成功!");
        }
        //返回一个提示对象
        return message;
    }

    /**
     * 根据教练员外键 修改是否查看
     * @param session
     * @param atsSchemeAthlete  运动员关联表对象
     * @return 返回一个提示对象
     */
    @ResponseBody
    @RequestMapping("addExp")
    public Message message(HttpSession session,AtsSchemeAthlete atsSchemeAthlete){
        //new出提示类
        Message message=new Message();
        //取出session的Tuser模型
        Tuser user = (Tuser) session.getAttribute("user");
        //判断4为运动员进来
        if("4".equals(user.getCompanyNum())){
            //传入session对象的外键
            atsSchemeAthlete.setAthleteId(Integer.valueOf(user.getFilId()));
            //调用带0zero的修改方法
            int rows=atsSchemeAthleteMentalService.updateByPrimaryKeySelectiveZero(atsSchemeAthlete);
            //判断大于0
            if(rows>0){
                //传入1
                message.setNum(1);
                message.setMsg("操作成功！");
            }else{
                //传入0
                message.setNum(0);
                message.setMsg("操作失败！");
            }
            //返回提示对象
            return message;
        }
        //返回空
        return null;
    }

    /**
     * 根据方案id查询运动员
     * @param schemeId  方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAthleteById")
    public List<AtsSchemeAthlete> selectAthleteById(Integer schemeId){
        List<AtsSchemeAthlete> atsSchemeAthlete=atsSchemeAthleteMentalService.selectByIdone(schemeId);
        return atsSchemeAthlete;
    }

    /**
     * 根据方案id 查询审核状态
     * @param saId 方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectBySaId")
    public AtsSchemeAudit selectBySaId(Integer saId){
        AtsSchemeAudit atsSchemeAthlete=atsSchemeAuditMentalService.selectBySchemeIdFour(saId);
        return atsSchemeAthlete;
    }

    /**
     * 根据方案id 查询专家
     * @param schemeId 方案id
     * @return
     */
    @ResponseBody
    @RequestMapping("selectAuExp")
    public AtsSchemeExpert selectAuExp(Integer schemeId){
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertMentalService.selectByPrimaryKeyFive(schemeId);
        return atsSchemeExpert;
    }
}
